Dec15, 2025

Como Integrar Camoufox com CapSolver para Resolução de CAPTCHA Sem Precedentes

Adélia Cruz

Neural Network Developer

TL;DR: Use o Camoufox para evadir a fingerprinting do navegador e o CapSolver para resolver automaticamente CAPTCHAs como Cloudflare Turnstile e reCAPTCHA v2/v3. Juntos, eles permitem automação web estável e semelhante à humana em larga escala com mínima detecção e altas taxas de sucesso.

Introdução

A automação web tornou-se essencial para coleta de dados, testes e várias operações comerciais. No entanto, sites modernos implementam medidas anti-bot sofisticadas e CAPTCHAs que podem interromper até mesmo scripts de automação bem elaborados.

A combinação do Camoufox e do CapSolver oferece uma solução poderosa para esse desafio:

Camoufox: Um navegador anti-detecto de código aberto baseado no Firefox que evita a detecção de bots por meio de injeção de fingerprint avançada
CapSolver: Um serviço de resolução de CAPTCHA baseado em IA que lida com Cloudflare Turnstile, reCAPTCHA e mais

Juntos, essas ferramentas permitem automação web sem interrupções que evita tanto a detecção de fingerprint quanto os desafios de CAPTCHA.

Objetivos da Integração

Este guia o ajudará a atingir três objetivos principais:

Evitar a Detecção de Bots - Use a injeção de fingerprint do Camoufox para parecer um navegador legítimo
Resolver CAPTCHAs Automaticamente - Integre a API do CapSolver para lidar com desafios de CAPTCHA sem intervenção manual
Manter Comportamento Semelhante ao Humano - Combine movimentos do mouse humanizados com resolução inteligente de CAPTCHA

O que é o Camoufox?

Camoufox é uma versão personalizada minimalista e discreta do Firefox projetada especificamente para raspagem de web e automação. Ao contrário de outras soluções anti-detecto que dependem de injeção de JavaScript (que pode ser detectada), o Camoufox implementa a injeção de fingerprint no nível C++ dentro do próprio navegador.

Funcionalidades Principais

Injeção de Fingerprint - Falsifica propriedades do navegador, dimensões da tela, WebGL, WebRTC, fontes e mais no nível nativo
Movimento do Mouse Semelhante ao Humano - Algoritmo integrado de humanização do cursor para interações realistas
Integração com BrowserForge - Gera fingerprints que imitam distribuições de dispositivos do mundo real
Suporte a GeoIP - Calcula automaticamente fuso horário, local e geolocalização com base no IP do proxy
Suporte a Adicionais do Firefox - Carrega extensões personalizadas, incluindo bloqueadores de anúncios

Instalação

bash Copy

# Instale o pacote Python
pip install -U camoufox[geoip]

# Baixe o navegador Camoufox
camoufox fetch

Uso Básico

python Copy

from camoufox.sync_api import Camoufox

with Camoufox(humanize=True) as browser:
    page = browser.new_page()
    page.goto("https://example.com")

O que é o CapSolver?

CapSolver é um serviço de resolução de CAPTCHA automático baseado em IA que suporta uma ampla gama de tipos de CAPTCHA. Ele fornece uma API simples que permite enviar desafios de CAPTCHA e receber soluções em segundos.

Tipos de CAPTCHA Suportados

Cloudflare Turnstile - O desafio anti-bot mais comum atualmente
reCAPTCHA v2 - Variantes baseadas em imagem e invisíveis
reCAPTCHA v3 - Verificação baseada em pontuação
AWS WAF - CAPTCHA da Amazon Web Services
E muitos mais...

Começando com o CapSolver

Registre-se em capsolver.com
Adicione fundos à sua conta
Obtenha sua chave de API no painel de controle

Bônus: Use o código CAMOUFOX ao se cadastrar para receber créditos extras!

Desafios Pré-Integração

Antes de combinar o Camoufox com o CapSolver, a automação web enfrentava vários problemas:

Desafio	Impacto
Detecção de fingerprint do navegador	Scripts bloqueados antes de atingirem o conteúdo
Desafios CAPTCHA	Resolução manual necessária, interrompendo a automação
Sistemas de reputação de IP	Proxies rapidamente marcados e banidos
Análise de comportamento	Padrões não humanos detectados

A integração do Camoufox + CapSolver resolve todos esses desafios em um único fluxo de trabalho.

Métodos de Integração

Método 1: Integração via API (Recomendado)

O método de integração via API oferece controle total sobre o processo de resolução de CAPTCHA e funciona com qualquer tipo de CAPTCHA.

Requisitos de Configuração

bash Copy

pip install camoufox[geoip] httpx

Padrão de Integração Básico

python Copy

import asyncio
import httpx
from camoufox.async_api import AsyncCamoufox

CAPSOLVER_API_KEY = "SUA_CHAVE_DE_API"
CAPSOLVER_API = "https://api.capsolver.com"


async def create_task(task_payload: dict) -> str:
    """Crie uma tarefa de resolução de CAPTCHA e retorne o ID da tarefa."""
    async with httpx.AsyncClient() as client:
        response = await client.post(
            f"{CAPSOLVER_API}/createTask",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "task": task_payload
            }
        )
        result = response.json()
        if result.get("errorId") != 0:
            raise Exception(f"Erro do CapSolver: {result.get('errorDescription')}")
        return result["taskId"]


async def get_task_result(task_id: str, max_attempts: int = 120) -> dict:
    """Verifique o resultado da tarefa até que seja resolvido ou expire o tempo."""
    async with httpx.AsyncClient() as client:
        for _ in range(max_attempts):
            response = await client.post(
                f"{CAPSOLVER_API}/getTaskResult",
                json={
                    "clientKey": CAPSOLVER_API_KEY,
                    "taskId": task_id
                }
            )
            result = response.json()

            if result.get("status") == "ready":
                return result["solution"]
            elif result.get("status") == "failed":
                raise Exception(f"Tarefa falhou: {result.get('errorDescription')}")

            await asyncio.sleep(1)

    raise TimeoutError("A resolução de CAPTCHA expirou!")


async def solve_captcha(task_payload: dict) -> dict:
    """Fluxo completo de resolução de CAPTCHA."""
    task_id = await create_task(task_payload)
    return await get_task_result(task_id)

Método 2: Extensão do Navegador

Você também pode usar a extensão do CapSolver com o Camoufox para uma abordagem mais automática.

Etapas de Instalação

Baixe a extensão do CapSolver em capsolver.com/en/extension
Extraia os arquivos da extensão
Carregue-a no Camoufox:

python Copy

from camoufox.sync_api import Camoufox

with Camoufox(
    addons=["/caminho/para/a/extensão/capsolver"],
    headless=False  # Extensões exigem modo com interface
) as browser:
    page = browser.new_page()
    # A extensão detectará e resolverá CAPTCHAs automaticamente

Exemplos de Código

Exemplo 1: Resolvendo Cloudflare Turnstile

Cloudflare Turnstile é um dos desafios de CAPTCHA mais comuns. Aqui está como resolvê-lo:

python Copy

import asyncio
from camoufox.async_api import AsyncCamoufox

CAPSOLVER_API_KEY = "SUA_CHAVE_DE_API"
CAPSOLVER_API = "https://api.capsolver.com"


async def solve_turnstile(site_key: str, page_url: str) -> str:
    """Resolva o Cloudflare Turnstile e retorne o token."""
    import httpx

    async with httpx.AsyncClient() as client:
        # Crie a tarefa
        response = await client.post(
            f"{CAPSOLVER_API}/createTask",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "task": {
                    "type": "AntiTurnstileTaskProxyLess",
                    "websiteURL": page_url,
                    "websiteKey": site_key,
                }
            }
        )
        task_id = response.json()["taskId"]

        # Verifique o resultado
        while True:
            result = await client.post(
                f"{CAPSOLVER_API}/getTaskResult",
                json={
                    "clientKey": CAPSOLVER_API_KEY,
                    "taskId": task_id
                }
            )
            data = result.json()

            if data.get("status") == "ready":
                return data["solution"]["token"]

            await asyncio.sleep(1)


async def main():
    target_url = "https://example.com/pagina-protegida"
    turnstile_site_key = "0x4XXXXXXXXXXXXXXXXX"  # Encontre isso no código da página

    async with AsyncCamoufox(
        humanize=True,
        headless=False,
        os="windows"
    ) as browser:
        page = await browser.new_page()
        await page.goto(target_url)

        # Aguarde o Turnstile carregar
        await page.wait_for_selector('input[name="cf-turnstile-response"]', timeout=10000)

        # Resolva o CAPTCHA
        token = await solve_turnstile(turnstile_site_key, target_url)
        print(f"Obteve token do Turnstile: {token[:50]}...")

        # Injete o token
        await page.evaluate(f'''
            document.querySelector('input[name="cf-turnstile-response"]').value = "{token}";

            // Defina o callback oculto se estiver presente
            const callback = document.querySelector('[data-callback]');
            if (callback) {{
                const callbackName = callback.getAttribute('data-callback');
                if (window[callbackName]) {{
                    window[callbackName]('{token}');
                }}
            }}
        ''')

        # Submeta o formulário
        await page.click('button[type="submit"]')
        await page.wait_for_load_state("networkidle")

        print("Turnstile evadido com sucesso!")


if __name__ == "__main__":
    asyncio.run(main())

Exemplo 2: Resolvendo reCAPTCHA v2

python Copy

import asyncio
from camoufox.async_api import AsyncCamoufox

CAPSOLVER_API_KEY = "SUA_CHAVE_DE_API"
CAPSOLVER_API = "https://api.capsolver.com"


async def solve_recaptcha_v2(site_key: str, page_url: str) -> str:
    """Resolva o reCAPTCHA v2 e retorne o token."""
    import httpx

    async with httpx.AsyncClient() as client:
        # Crie a tarefa
        response = await client.post(
            f"{CAPSOLVER_API}/createTask",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "task": {
                    "type": "ReCaptchaV2TaskProxyLess",
                    "websiteURL": page_url,
                    "websiteKey": site_key,
                }
            }
        )
        result = response.json()

        if result.get("errorId") != 0:
            raise Exception(f"Erro: {result.get('errorDescription')}")

        task_id = result["taskId"]

        # Verifique o resultado
        while True:
            result = await client.post(
                f"{CAPSOLVER_API}/getTaskResult",
                json={
                    "clientKey": CAPSOLVER_API_KEY,
                    "taskId": task_id
                }
            )
            data = result.json()

            if data.get("status") == "ready":
                return data["solution"]["gRecaptchaResponse"]
            elif data.get("status") == "failed":
                raise Exception(f"Falha: {data.get('errorDescription')}")

            await asyncio.sleep(2)


async def main():
    target_url = "https://example.com/login"
    recaptcha_site_key = "6LcXXXXXXXXXXXXXXXXXXXXXXXXX"  # Encontre no código da página

    async with AsyncCamoufox(
        humanize=True,
        headless=False,
        os=["windows", "macos"]  # Seleção aleatória de sistema operacional
    ) as browser:
        page = await browser.new_page()
        await page.goto(target_url)

        # Preencha os campos do formulário com pausas semelhantes às humanas
        await page.fill('input[name="username"]', "user@example.com")
        await asyncio.sleep(0.5)  # Pausa semelhante à humana
        await page.fill('input[name="password"]', "password123")

        # Resolva o CAPTCHA
        print("Resolvendo reCAPTCHA v2...")
        token = await solve_recaptcha_v2(recaptcha_site_key, target_url)
        print(f"Obteve token: {token[:50]}...")

        # Injete o token no campo de resposta do reCAPTCHA
        await page.evaluate(f'''
            document.getElementById('g-recaptcha-response').innerHTML = '{token}';
            document.getElementById('g-recaptcha-response').style.display = 'block';
        ''')

        # Submeta o formulário
        await page.click('button[type="submit"]')
        await page.wait_for_load_state("networkidle")

        print("Login bem-sucedido!")


if __name__ == "__main__":
    asyncio.run(main())

Exemplo 3: Resolvendo reCAPTCHA v3

O reCAPTCHA v3 é baseado em pontuação e não exige interação do usuário. Você precisa especificar o parâmetro de ação.

python Copy

import asyncio
from camoufox.async_api import AsyncCamoufox

CAPSOLVER_API_KEY = "SUA_CHAVE_DE_API"
CAPSOLVER_API = "https://api.capsolver.com"


async def solve_recaptcha_v3(
    site_key: str,
    page_url: str,
    action: str = "verify",
    min_score: float = 0.7
) -> str:
    """Resolva o reCAPTCHA v3 com ação e pontuação mínima especificadas."""
    import httpx

    async with httpx.AsyncClient() as client:
        response = await client.post(
            f"{CAPSOLVER_API}/createTask",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "task": {
                    "type": "ReCaptchaV3TaskProxyLess",
                    "websiteURL": page_url,
                    "websiteKey": site_key,
                    "pageAction": action,
                    "minScore": min_score
                }
            }
        )
        result = response.json()

        if result.get("errorId") != 0:
            raise Exception(f"Erro: {result.get('errorDescription')}")

        task_id = result["taskId"]

        while True:
            result = await client.post(
                f"{CAPSOLVER_API}/getTaskResult",
                json={
                    "clientKey": CAPSOLVER_API_KEY,
                    "taskId": task_id
                }
            )
            data = result.json()

            if data.get("status") == "ready":
                return data["solution"]["gRecaptchaResponse"]
            elif data.get("status") == "failed":
                raise Exception(f"Falha: {data.get('errorDescription')}")

            await asyncio.sleep(1)


async def main():
    target_url = "https://example.com/pesquisa"
    recaptcha_v3_key = "6LcXXXXXXXXXXXXXXXXXXXXXXXXX"

    async with AsyncCamoufox(
        humanize=2.0,  # Máximo de 2 segundos de movimentos humanizados
        headless=True,  # Pode ser executado em modo headless para v3
        geoip=True,  # Detecta automaticamente a geolocalização a partir do proxy
    ) as browser:
        page = await browser.new_page()
        await page.goto(target_url)

        # Resolva o reCAPTCHA v3 com ação "pesquisa"
        print("Resolvendo reCAPTCHA v3...")
        token = await solve_recaptcha_v3(
            recaptcha_v3_key,
            target_url,
            action="pesquisa",
            min_score=0.9  # Solicite uma pontuação alta
        )

        # Execute o callback com o token
        await page.evaluate(f'''
            // Envie o token via callback do site

grecaptcha.execute('{chave_v3_recaptcha}', {{ação: 'pesquisa'}})
.then(function(tokenOriginal) {{
// Substitua pelo nosso token resolvido
enviarPesquisa('{token}');
}});
''')

Copy

    print("bypass de reCAPTCHA v3 concluído!")

if name == "main":
asyncio.run(main())

Copy

---

## Boas Práticas

### 1. Rotação de Proxy com GeoIP

Use o recurso de GeoIP do Camoufox para corresponder automaticamente aos impressões digitais com a localização do seu proxy:

```python
async with AsyncCamoufox(
    geoip=True,  # Detectar automaticamente a partir do IP do proxy
    proxy={
        "servidor": "http://proxy.example.com:8080",
        "usuario": "user",
        "senha": "pass"
    }
) as browser:
    # A impressão digital corresponderá à localização geográfica do proxy
    pass

2. Consistência da Impressão Digital

Mantenha as impressões digitais consistentes dentro de uma sessão, mas altere-as entre sessões:

python Copy

from browserforge.fingerprints import Tela

# Restrinja para tamanhos de tela comuns
tela = Tela(
    largura_min=1280,
    largura_max=1920,
    altura_min=720,
    altura_max=1080
)

async with AsyncCamoufox(
    sistema_operacional="windows",
    tela=tela,
) as browser:
    pass

3. Limitação de Taxa

Evite disparar limites de taxa adicionando atrasos:

python Copy

import random

async def atraso_humano():
    """Atraso aleatório para imitar comportamento humano."""
    await asyncio.sleep(random.uniform(1.0, 3.0))

# Use entre ações
await page.clicar('botão')
await atraso_humano()
await page.preencher('input', 'texto')

4. Tratamento de Erros

Sempre implemente tratamento adequado de erros para resolução de CAPTCHA:

python Copy

async def resolver_com_retentativas(payload_tarefa: dict, max_tentativas: int = 3) -> dict:
    """Resolver CAPTCHA com lógica de tentativas."""
    for tentativa in range(max_tentativas):
        try:
            return await resolver_captcha(payload_tarefa)
        except TimeoutError:
            if tentativa < max_tentativas - 1:
                print(f"Tempo esgotado, tentando novamente... ({tentativa + 1}/{max_tentativas})")
                await asyncio.sleep(5)
            else:
                raise
        except Exception as e:
            if "saldo" in str(e).lower():
                raise  # Não tentar novamente em erros de saldo
            if tentativa < max_tentativas - 1:
                await asyncio.sleep(2)
            else:
                raise

Bônus: Comece Hoje Mesmo!

Pronto para impulsionar sua automação web com o Camoufox e o CapSolver?

Use o código CAMOUFOX ao se inscrever no CapSolver para receber créditos extras!

Esse bônus exclusivo ajuda você a começar a resolver CAPTCHAs imediatamente.

Conclusão

A integração do Camoufox e do CapSolver cria uma ferramenta poderosa para automação web:

Camoufox lida com detecção de bots com spoofing de impressão digital de nível nativo
CapSolver lida com CAPTCHAs com resolução baseada em IA
Juntos eles permitem automação sem interrupções que parece totalmente humana

Seja você construindo raspadores de web, sistemas de testes automatizados ou pipelines de coleta de dados, essa combinação oferece a confiabilidade e o disfarce que você precisa.

Perguntas Frequentes

Q: Quais tipos de CAPTCHA funcionam melhor com essa integração?

A: O CapSolver suporta todos os principais tipos de CAPTCHA. Turnstile da Cloudflare e reCAPTCHA v2/v3 têm as maiores taxas de sucesso. A integração funciona perfeitamente com qualquer CAPTCHA que o CapSolver suporte.

Q: Posso usar isso no modo headless?

A: Sim! O Camoufox suporta o modo headless e mantém suas capacidades de spoofing de impressão digital. Para reCAPTCHA v3 e CAPTCHAs baseados em token, o modo headless funciona perfeitamente. Para CAPTCHAs v2 visíveis, o modo headed pode oferecer melhores resultados.

Q: Como encontrar a site key de um CAPTCHA?

A: Procure no código fonte da página por:

Turnstile: atributo data-sitekey ou elementos cf-turnstile
reCAPTCHA: atributo data-sitekey no div g-recaptcha

Q: O que fazer se a resolução do CAPTCHA falhar?

A: Soluções comuns:

Verifique sua chave de API e saldo
Certifique-se de que a site key está correta
Verifique se a URL da página corresponde à onde o CAPTCHA aparece
Para v3, tente ajustar o parâmetro de ação e a pontuação mínima
Implemente lógica de tentativa com atrasos

Q: O Camoufox funciona com o Selenium?

A: O Camoufox é baseado no Playwright, não no Selenium. No entanto, você pode usar o mesmo padrão de integração com a API do CapSolver com qualquer framework de automação de navegador.

Ver mais

web scrapingApr 22, 2026

Arquitetura de Web Scraping em Rust para Extração de Dados Escalável

Aprenda arquitetura de raspagem web escalável em Rust com reqwest, scraper, raspagem assíncrona, raspagem de navegador headless, rotação de proxies e tratamento de CAPTCHA compatível.

Adélia Cruz

web scrapingApr 08, 2026

Selenium vs Puppeteer para Resolução de CAPTCHA: Comparação de Desempenho e Caso de Uso

Compare o Selenium vs Puppeteer para resolver CAPTCHA. Descubra benchmarks de desempenho, notas de estabilidade e como integrar o CapSolver para o máximo de sucesso.

Como Integrar Camoufox com CapSolver para Resolução de CAPTCHA Sem Precedentes

Introdução

Objetivos da Integração

O que é o Camoufox?

Funcionalidades Principais

Instalação

Uso Básico

O que é o CapSolver?

Tipos de CAPTCHA Suportados

Começando com o CapSolver

Desafios Pré-Integração

Métodos de Integração

Método 1: Integração via API (Recomendado)

Requisitos de Configuração

Padrão de Integração Básico

Método 2: Extensão do Navegador

Etapas de Instalação

Exemplos de Código

Exemplo 1: Resolvendo Cloudflare Turnstile

Exemplo 2: Resolvendo reCAPTCHA v2

Exemplo 3: Resolvendo reCAPTCHA v3

2. Consistência da Impressão Digital

3. Limitação de Taxa

4. Tratamento de Erros

Bônus: Comece Hoje Mesmo!

Conclusão

Perguntas Frequentes

Q: Quais tipos de CAPTCHA funcionam melhor com essa integração?

Q: Posso usar isso no modo headless?

Q: Como encontrar a site key de um CAPTCHA?

Q: O que fazer se a resolução do CAPTCHA falhar?

Q: O Camoufox funciona com o Selenium?

Ver mais

Arquitetura de Web Scraping em Rust para Extração de Dados Escalável

Selenium vs Puppeteer para Resolução de CAPTCHA: Comparação de Desempenho e Caso de Uso

Como Integrar Camoufox com CapSolver para Resolução de CAPTCHA Sem Precedentes

Introdução

Objetivos da Integração

O que é o Camoufox?

Funcionalidades Principais

Instalação

Uso Básico

O que é o CapSolver?

Tipos de CAPTCHA Suportados

Começando com o CapSolver

Desafios Pré-Integração

Métodos de Integração

Método 1: Integração via API (Recomendado)

Requisitos de Configuração

Padrão de Integração Básico

Método 2: Extensão do Navegador

Etapas de Instalação

Exemplos de Código

Exemplo 1: Resolvendo Cloudflare Turnstile

Exemplo 2: Resolvendo reCAPTCHA v2

Exemplo 3: Resolvendo reCAPTCHA v3

2. Consistência da Impressão Digital

3. Limitação de Taxa

4. Tratamento de Erros

Bônus: Comece Hoje Mesmo!

Conclusão

Perguntas Frequentes

Q: Quais tipos de CAPTCHA funcionam melhor com essa integração?

Q: Posso usar isso no modo headless?

Q: Como encontrar a site key de um CAPTCHA?

Q: O que fazer se a resolução do CAPTCHA falhar?

Q: O Camoufox funciona com o Selenium?

Ver mais

Arquitetura de Web Scraping em Rust para Extração de Dados Escalável

Selenium vs Puppeteer para Resolução de CAPTCHA: Comparação de Desempenho e Caso de Uso

Dados como Serviço (DaaS): O que é e por que importa em 2026

Como corrigir erros comuns de raspagem da web em 2026